面试中的 TypeScript

// 扩展方式差异
interface Animal {
  name: string;
}
interface Dog extends Animal {
  breed: string;
}
 
type AnimalType = {
  name: string;
};
type DogType = AnimalType & {
  breed: string;
};
 
// 声明合并：interface 支持，type 不支持
interface Config {
  host: string;
}
interface Config {
  // 合并时必须兼容已有结构
  port: number;
}
// Config 现在包含 host 与 port
 
// type 不允许重复声明
// type ConfigType = { host: string; }
// type ConfigType = { port: number; } // ❌ 报错：重复标识符
 
// 表达能力差异：type 可以表示元组、联合类型
type TupleType = [string, number];
type UnionType = string | number | boolean;
// interface 无法直接表达这些

// interface：描述对象对外暴露的接口，不应具有复杂的类型逻辑
interface UserService {
  getUser(id: string): Promise<User>;
  updateUser(id: string, data: Partial<User>): Promise<User>;
}
 
// type：处理函数签名、联合类型、工具类型等复杂类型编程
type AsyncFunction<T> = (...args: any[]) => Promise<T>;
type Result<T> = { success: true; data: T } | { success: false; error: string };

// 接口继承：编译器只需检查新增属性
interface Base {
  foo: string;
}
interface Extended extends Base {
  bar: number;
}
 
// 交叉类型：编译器需要合并所有属性，深层嵌套时性能差距明显
type BaseType = {
  foo: string;
};
type ExtendedType = BaseType & {
  bar: number;
};

// 结构化类型：只看结构，不问出处
class Cat {
  eat() {}
}
class Dog {
  eat() {}
}
 
function feedCat(cat: Cat) {}
 
// 通过！Dog 与 Cat 结构一致
feedCat(new Dog());
 
// 子类型关系：更多属性的类型是更少属性类型的子类型
interface Point2D {
  x: number;
  y: number;
}
interface Point3D {
  x: number;
  y: number;
  z: number;
}
 
const point3D: Point3D = { x: 1, y: 2, z: 3 };
const point2D: Point2D = point3D; // ✅ Point3D 是 Point2D 的子类型

// 结构化类型的问题：不同语义但结构相同的类型可以互换
type USD = number;
type CNY = number;
 
const price: USD = 100;
const cost: CNY = price; // ⚠️ 通过！但语义上美元和人民币不应互换
 
// 使用品牌类型模拟标称类型系统
type Brand<T, B> = T & { __brand: B };
type USDBrand = Brand<number, "USD">;
type CNYBrand = Brand<number, "CNY">;
 
const usdPrice: USDBrand = 100 as USDBrand;
const cnyCost: CNYBrand = usdPrice; // ❌ 报错！类型不兼容

// 类型层级（自底向上）
// never ⊂ 字面量类型 ⊂ 对应基础类型 ⊂ 联合类型 ⊂ unknown
//                                                ↑ any（特殊：双向兼容）
 
// 示例：
type T1 = "hello" extends string ? true : false;   // true
type T2 = string extends "hello" ? true : false;   // false
type T3 = string extends unknown ? true : false;    // true
type T4 = never extends string ? true : false;      // true

// Top Type：所有类型都可以赋值给它
let anyVal: any = "hello";
anyVal = 42;
anyVal = { foo: "bar" };
 
let unknownVal: unknown = "hello";
unknownVal = 42;
unknownVal = { foo: "bar" };
 
// Bottom Type：可以赋值给任何类型
function throwError(msg: string): never {
  throw new Error(msg);
}
 
const num: number = throwError("error"); // ✅ never 可赋值给 number
 
// any vs unknown 的关键区别
let a: any = "hello";
a.toUpperCase(); // ✅ 不报错（但运行时可能出错）
 
let b: unknown = "hello";
// b.toUpperCase(); // ❌ 报错：unknown 类型上不存在 toUpperCase
if (typeof b === "string") {
  b.toUpperCase(); // ✅ 收窄后可使用
}

// Top Type：无法对所有地方都精确描述类型时，需要一个兜底
// 比如第三方库的类型不完整、JSON.parse 的返回值等
const data: unknown = JSON.parse(input);
 
// Bottom Type：两个不存在交集的类型强行交集运算的结果
type Intersection = string & number; // never —— 不存在的类型
 
// 条件类型中的分支收窄
type StrOrNum<T> = T extends string
  ? string
  : T extends number
    ? number
    : never; // 不可能走到这里，用 never 表示

// 类型层级链（自底向上）
// never → 字面量类型 → 基础类型 → 对象/联合类型 → unknown
//                                               any（双向往来）
 
// 验证层级
type IsNeverSubsetOfNumber = never extends number ? true : false;   // true
type IsStringSubsetOfUnknown = string extends unknown ? true : false; // true
type IsUnknownTopType = unknown extends string ? true : false;       // false

// any 在条件类型中：既成立又不成立（分布式行为）
type AnyInConditional = any extends string ? true : false; // boolean（true | false）
 
// never 在条件类型中：直接返回 never（空集的分布式结果）
type NeverInConditional = never extends string ? true : false; // never
 
// 对比普通类型
type StringInConditional = string extends "hello" ? true : false; // false

// Partial：将属性变为可选
type MyPartial<T> = {
  [K in keyof T]?: T[K];
};
 
// Required：将属性变为必选
type MyRequired<T> = {
  [K in keyof T]-?: T[K];
};
 
// Pick：选取部分属性
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};
 
// Omit：排除部分属性
type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
// ReturnType：获取函数返回值类型
type MyReturnType<T extends (...args: any) => any> =
  T extends (...args: any) => infer R ? R : never;
 
// Parameters：获取函数参数类型（元组）
type MyParameters<T extends (...args: any) => any> =
  T extends (...args: infer P) => any ? P : never;

// DeepPartial：递归地将所有嵌套属性变为可选
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object
    ? T[K] extends Function
      ? T[K]          // 函数类型不递归
      : DeepPartial<T[K]>  // 对象类型递归处理
    : T[K];
};
 
// 使用示例
interface Config {
  database: {
    host: string;
    port: number;
    options: {
      ssl: boolean;
      timeout: number;
    };
  };
}
 
type PartialConfig = DeepPartial<Config>;
// database?, database.host?, database.options.ssl? 等全部可选
 
// MarkAsPartial：将指定属性标记为可选
type MarkAsPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 
// PickByType：按值的类型选取属性
type PickByType<T, ValueType> = {
  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
};
 
interface User {
  name: string;
  age: number;
  email: string;
  active: boolean;
}
 
type StringProps = PickByType<User, string>;
// { name: string; email: string }

// 协变：返回值类型方向一致
type Animal = { name: string };
type Dog = { name: string; breed: string };
 
// Dog 是 Animal 的子类型
// () => Dog 也是 () => Animal 的子类型 —— 协变
type AnimalGetter = () => Animal;
type DogGetter = () => Dog;
 
let getAnimal: AnimalGetter = () => ({ name: "cat" });
let getDog: DogGetter = () => ({ name: "rex", breed: "husky" });
 
getAnimal = getDog; // ✅ 协变：DogGetter 可以赋值给 AnimalGetter
// getDog = getAnimal; // ❌ 反方向不行：AnimalGetter 不能赋值给 DogGetter

// 逆变：参数类型方向反转
type LogAnimal = (animal: Animal) => void;
type LogDog = (dog: Dog) => void;
 
let logAnimal: LogAnimal = (a) => console.log(a.name);
let logDog: LogDog = (d) => console.log(d.name, d.breed);
 
// 逆变：LogAnimal 可以赋值给 LogDog（参数类型方向反转）
logDog = logAnimal; // ✅ 严格模式下（strictFunctionTypes: true）
// logAnimal = logDog; // ❌ 反方向不行

// strictFunctionTypes: false（默认宽松模式）—— 双变
// 函数参数既允许协变也允许逆变，检查更宽松但不够安全
 
// strictFunctionTypes: true（推荐）—— 逆变
// 函数参数严格按逆变检查，类型更安全
 
// 方法 vs 函数属性的区别
interface Example {
  // 方法语法：不受 strictFunctionTypes 影响（双变）
  method(arg: Dog): void;
  // 函数属性语法：受 strictFunctionTypes 影响（逆变）
  property: (arg: Dog) => void;
}